<html lang="zh-CN"><head><meta charset="UTF-8"><style>.nodata  main {width:1000px;margin: auto;}</style></head><body class="nodata " style=""><div class="main_father clearfix d-flex justify-content-center " style="height:100%;"> <div class="container clearfix " id="mainBox"><main><div class="blog-content-box">
<div class="article-header-box">
<div class="article-header">
<div class="article-title-box">
<h1 class="title-article" id="articleContentId">(C卷,100分)- 虚拟理财游戏（Java & JS & Python & C）</h1>
</div>
</div>
</div>
<div id="blogHuaweiyunAdvert"></div>

        <div id="article_content" class="article_content clearfix">
        <link rel="stylesheet" href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/kdoc_html_views-1a98987dfd.css">
        <link rel="stylesheet" href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/ck_htmledit_views-044f2cf1dc.css">
                <div id="content_views" class="htmledit_views">
                    <h4 id="main-toc">题目描述</h4> 
<p>在一款虚拟游戏中生活&#xff0c;你必须进行投资以增强在虚拟游戏中的资产以免被淘汰出局。</p> 
<p>现有一家Bank&#xff0c;它提供有若干理财产品 m 个&#xff0c;风险及投资回报不同&#xff0c;你有 N&#xff08;元&#xff09;进行投资&#xff0c;能接收的总风险值为X。</p> 
<p>你要在可接受范围内选择最优的投资方式获得最大回报。</p> 
<p></p> 
<p>备注&#xff1a;</p> 
<ul><li>在虚拟游戏中&#xff0c;每项投资风险值相加为总风险值&#xff1b;</li><li>在虚拟游戏中&#xff0c;最多只能投资2个理财产品&#xff1b;</li><li>在虚拟游戏中&#xff0c;最小单位为整数&#xff0c;不能拆分为小数&#xff1b;</li><li>投资额*回报率&#61;投资回报</li></ul> 
<p></p> 
<h4 id="%E8%BE%93%E5%85%A5%E6%8F%8F%E8%BF%B0">输入描述</h4> 
<p>第一行&#xff1a;</p> 
<ul><li>产品数&#xff08;取值范围[1,20]&#xff09;</li><li>总投资额&#xff08;整数&#xff0c;取值范围[1, 10000]&#xff09;</li><li>可接受的总风险&#xff08;整数&#xff0c;取值范围[1,200]&#xff09;</li></ul> 
<p>第二行&#xff1a;产品投资回报率序列&#xff0c;输入为整数&#xff0c;取值范围[1,60]</p> 
<p>第三行&#xff1a;产品风险值序列&#xff0c;输入为整数&#xff0c;取值范围[1, 100]</p> 
<p>第四行&#xff1a;最大投资额度序列&#xff0c;输入为整数&#xff0c;取值范围[1, 10000]</p> 
<p></p> 
<h4 id="%E8%BE%93%E5%87%BA%E6%8F%8F%E8%BF%B0">输出描述</h4> 
<p>每个产品的投资额序列</p> 
<p></p> 
<h4 id="%E7%94%A8%E4%BE%8B">用例</h4> 
<table border="1" cellpadding="1" cellspacing="1" style="width:500px;"><tbody><tr><td style="width:86px;">输入</td><td style="width:412px;">5 100 10<br /> 10 20 30 40 50<br /> 3 4 5 6 10<br /> 20 30 20 40 30</td></tr><tr><td style="width:86px;">输出</td><td style="width:412px;">0 30 0 40 0</td></tr><tr><td style="width:86px;">说明</td><td style="width:412px;">投资第二项30个单位&#xff0c;第四项40个单位&#xff0c;总的投资风险为两项相加为4&#43;6&#61;10</td></tr></tbody></table> 
<p></p> 
<h4 id="%E9%A2%98%E7%9B%AE%E8%A7%A3%E6%9E%90">题目解析</h4> 
<p>第一眼看这题有点像二维费用背包&#xff0c;但是本题备注中有一个关键限制&#xff1a;</p> 
<blockquote> 
 <p>在虚拟游戏中&#xff0c;最多只能投资2个理财产品&#xff1b;</p> 
</blockquote> 
<p>那么本题其实就变成了&#xff1a;m个理财产品中选1个或2个&#xff0c;所选产品风险值之和 ≤ x&#xff0c;投资额之和 ≤ n&#xff0c;并且最终所选产品的投资回报之和最大。</p> 
<p>由于 m 的数量级不大&#xff0c;取值范围[1,20]&#xff0c;因此可以考虑暴力破解。</p> 
<p></p> 
<h4 id="%E7%AE%97%E6%B3%95%E6%BA%90%E7%A0%81">JS算法源码</h4> 
<pre><code class="language-javascript">const rl &#61; require(&#34;readline&#34;).createInterface({ input: process.stdin });
var iter &#61; rl[Symbol.asyncIterator]();
const readline &#61; async () &#61;&gt; (await iter.next()).value;

void (async function () {
  // 产品数, 总投资, 总风险
  const [m, n, x] &#61; (await readline()).split(&#34; &#34;).map(Number);

  // 产品回报率序列
  const back &#61; (await readline()).split(&#34; &#34;).map(Number);
  // 产品风险值序列
  const risk &#61; (await readline()).split(&#34; &#34;).map(Number);
  // 产品投资额序列
  const invest &#61; (await readline()).split(&#34; &#34;).map(Number);

  let max_invest_back &#61; 0;
  let select &#61; {};

  for (let i &#61; 0; i &lt; m; i&#43;&#43;) {
    // 如果单个产品的投资风险未超过总风险&#xff0c;则投资单个产品
    if (risk[i] &lt;&#61; x) {
      // 产品I的投资额不能超过该产品的最大投资额&#xff0c;以及总投资
      const investI &#61; Math.min(invest[i], n);
      // 产品投资回报
      const invest_back &#61; investI * back[i];

      // 如果投资回报高于其他产品组合&#xff0c;那么选择该产品
      if (invest_back &gt; max_invest_back) {
        max_invest_back &#61; invest_back;
        select &#61; {};
        select[i] &#61; investI;
      }
    } else {
      continue;
    }

    for (let j &#61; i &#43; 1; j &lt; m; j&#43;&#43;) {
      // 如果两个产品的风险和不超过了总风险&#xff0c;那么两个产品都选
      if (risk[i] &#43; risk[j] &lt;&#61; x) {
        let investI; // 产品I的投资额
        let investJ; // 产品J的投资额

        // 其中优先投资回报率大的
        if (back[i] &gt; back[j]) {
          // 产品I回报率高&#xff0c;则能投多少投多少&#xff0c;最多不能超过min(总投资, 产品I的最多投资额)
          investI &#61; Math.min(n, invest[i]);
          // 留给产品J的剩余钱未 n - investI, 而产品J最多投资invest[j]&#xff0c;因此取二者较小值
          investJ &#61; Math.min(n - investI, invest[j]);
        } else {
          investJ &#61; Math.min(n, invest[j]);
          investI &#61; Math.min(n - investJ, invest[i]);
        }

        // 总投资回报
        const invest_back &#61; investI * back[i] &#43; investJ * back[j];

        // 如果当前产品组合的总回报更大&#xff0c;则选当前组合产品
        if (invest_back &gt; max_invest_back) {
          max_invest_back &#61; invest_back;
          select &#61; {};
          // select的key记录产品的ID&#xff0c;val记录产品的投资额
          if (investI &gt; 0) select[i] &#61; investI;
          if (investJ &gt; 0) select[j] &#61; investJ;
        }
      }
    }
  }

  const res &#61; [];
  for (let i &#61; 0; i &lt; m; i&#43;&#43;) {
    if (select[i] !&#61; undefined) {
      res.push(select[i]);
    } else {
      res.push(&#34;0&#34;);
    }
  }

  console.log(res.join(&#34; &#34;));
})();
</code></pre> 
<p></p> 
<h4 id="Java%E7%AE%97%E6%B3%95%E6%BA%90%E7%A0%81">Java算法源码</h4> 
<pre><code class="language-java">import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    Scanner sc &#61; new Scanner(System.in);

    int[] tmp &#61; Arrays.stream(sc.nextLine().split(&#34; &#34;)).mapToInt(Integer::parseInt).toArray();

    int m &#61; tmp[0]; // 产品数
    int n &#61; tmp[1]; // 总投资
    int x &#61; tmp[2]; // 总风险

    // 产品回报率序列
    int[] back &#61; Arrays.stream(sc.nextLine().split(&#34; &#34;)).mapToInt(Integer::parseInt).toArray();

    // 产品风险值序列
    int[] risk &#61; Arrays.stream(sc.nextLine().split(&#34; &#34;)).mapToInt(Integer::parseInt).toArray();

    // 产品投资额序列
    int[] invest &#61; Arrays.stream(sc.nextLine().split(&#34; &#34;)).mapToInt(Integer::parseInt).toArray();

    int max_invest_back &#61; 0;
    HashMap&lt;Integer, Integer&gt; select &#61; new HashMap&lt;&gt;();

    for (int i &#61; 0; i &lt; m; i&#43;&#43;) {
      // 如果单个产品的投资风险未超过总风险&#xff0c;则投资单个产品
      if (risk[i] &lt;&#61; x) {
        // 产品I的投资额不能超过该产品的最大投资额&#xff0c;以及总投资
        int investI &#61; Math.min(invest[i], n);
        // 产品投资回报
        int invest_back &#61; investI * back[i];

        // 如果投资回报高于其他产品组合&#xff0c;那么选择该产品
        if (invest_back &gt; max_invest_back) {
          max_invest_back &#61; invest_back;
          select.clear();
          select.put(i, investI);
        }
      } else {
        continue;
      }

      for (int j &#61; i &#43; 1; j &lt; m; j&#43;&#43;) {

        // 如果两个产品的风险和不超过了总风险&#xff0c;那么两个产品都选
        if (risk[i] &#43; risk[j] &lt;&#61; x) {
          // 产品I的投资额
          int investI;
          // 产品J的投资额
          int investJ;

          // 其中优先投资回报率大的
          if (back[i] &gt; back[j]) {
            // 产品I回报率高&#xff0c;则能投多少投多少&#xff0c;最多不能超过min(总投资, 产品I的最多投资额)
            investI &#61; Math.min(n, invest[i]);
            // 留给产品J的剩余钱未 n - investI, 而产品J最多投资invest[j]&#xff0c;因此取二者较小值
            investJ &#61; Math.min(n - investI, invest[j]);
          } else {
            investJ &#61; Math.min(n, invest[j]);
            investI &#61; Math.min(n - investJ, invest[i]);
          }

          // 总投资回报
          int invest_back &#61; investI * back[i] &#43; investJ * back[j];

          // 如果当前产品组合的总回报更大&#xff0c;则选当前组合产品
          if (invest_back &gt; max_invest_back) {
            max_invest_back &#61; invest_back;
            select.clear();
            // select的key记录产品的ID&#xff0c;val记录产品的投资额
            if (investI &gt; 0) select.put(i, investI);
            if (investJ &gt; 0) select.put(j, investJ);
          }
        }
      }
    }

    StringJoiner sj &#61; new StringJoiner(&#34; &#34;);
    for (int i &#61; 0; i &lt; m; i&#43;&#43;) {
      if (select.containsKey(i)) {
        sj.add(select.get(i) &#43; &#34;&#34;);
      } else {
        sj.add(&#34;0&#34;);
      }
    }

    System.out.println(sj);
  }
}
</code></pre> 
<p></p> 
<h4 id="Python%E7%AE%97%E6%B3%95%E6%BA%90%E7%A0%81">Python算法源码</h4> 
<pre><code class="language-python"># 输入获取
m, n, x &#61; map(int, input().split())  # 产品数, 总投资, 总风险

# 产品回报率序列
back &#61; list(map(int, input().split()))
# 产品风险值序列
risk &#61; list(map(int, input().split()))
# 产品投资额序列
invest &#61; list(map(int, input().split()))

# 记录所选产品的最大投资回报
max_invest_back &#61; 0
# 记录所选产品的序号
select &#61; {}

# 选两个产品时
for i in range(m):
    # 如果单个产品的投资风险未超过总风险&#xff0c;则投资单个产品
    if risk[i] &lt;&#61; x:
        # 产品I的投资额不能超过该产品的最大投资额&#xff0c;以及总投资
        investI &#61; min(invest[i], n)
        # 产品投资回报
        invest_back &#61; investI * back[i]

        # 如果投资回报高于其他产品组合&#xff0c;那么选择该产品
        if invest_back &gt; max_invest_back:
            max_invest_back &#61; invest_back
            select.clear()
            select[i] &#61; investI
    else:
        continue

    for j in range(i &#43; 1, m):
        # 如果两个产品的风险和不超过了总风险&#xff0c;那么两个产品都选
        if risk[i] &#43; risk[j] &lt;&#61; x:
            investI &#61; 0  # 产品I的投资额
            investJ &#61; 0  # 产品J的投资额

            # 其中优先投资回报率大的
            if back[i] &gt; back[j]:
                # 产品I回报率高&#xff0c;则能投多少投多少&#xff0c;最多不能超过min(总投资, 产品I的最多投资额)
                investI &#61; min(n, invest[i])
                # 留给产品J的剩余钱未 n - investI, 而产品J最多投资invest[j]&#xff0c;因此取二者较小值
                investJ &#61; min(n - investI, invest[j])
            else:
                investJ &#61; min(n, invest[j])
                investI &#61; min(n - investJ, invest[i])

            # 总投资回报
            invest_back &#61; investI * back[i] &#43; investJ * back[j]

            # 如果当前产品组合的总回报更大&#xff0c;则选当前组合产品
            if invest_back &gt; max_invest_back:
                max_invest_back &#61; invest_back
                select.clear()
                # select的key记录产品的ID&#xff0c;val记录产品的投资额
                if investI &gt; 0:
                    select[i] &#61; investI
                if investJ &gt; 0:
                    select[j] &#61; investJ

res &#61; []
for i in range(m):
    if i in select:
        res.append(select[i])
    else:
        res.append(0)

print(&#34; &#34;.join(map(str, res)))</code></pre> 
<p></p> 
<h4 id="C%E7%AE%97%E6%B3%95%E6%BA%90%E7%A0%81" style="background-color:transparent;">C算法源码</h4> 
<pre><code class="language-cpp">#include &lt;stdio.h&gt;

#define MIN(a, b) ((a) &lt; (b) ? (a) : (b))

int main() {
    // 产品数, 总投资, 总风险
    int m, n, x;
    scanf(&#34;%d %d %d&#34;, &amp;m, &amp;n, &amp;x);

    // 产品回报率序列
    int back[m];
    for (int i &#61; 0; i &lt; m; i&#43;&#43;) scanf(&#34;%d&#34;, &amp;back[i]);

    // 产品风险值序列
    int risk[m];
    for (int i &#61; 0; i &lt; m; i&#43;&#43;) scanf(&#34;%d&#34;, &amp;risk[i]);

    // 产品投资额序列
    int invest[m];
    for (int i &#61; 0; i &lt; m; i&#43;&#43;) scanf(&#34;%d&#34;, &amp;invest[i]);

    // 记录所选产品的最大投资回报
    int max_invest_back &#61; 0;

    // 记录所选产品的序号
    int selectId[] &#61; {-1, -1};
    int selectFee[] &#61; {0, 0};


    for (int i &#61; 0; i &lt; m; i&#43;&#43;) {
        // 如果单个产品的投资风险未超过总风险&#xff0c;则投资单个产品
        if (risk[i] &lt;&#61; x) {
            // 产品I的投资额不能超过该产品的最大投资额&#xff0c;以及总投资
            int investI &#61; MIN(invest[i], n);
            // 产品投资回报
            int invest_back &#61; investI * back[i];

            // 如果投资回报高于其他产品组合&#xff0c;那么选择该产品
            if (invest_back &gt; max_invest_back) {
                max_invest_back &#61; invest_back;
                selectId[0] &#61; i;
                selectFee[0] &#61; investI;

                selectId[1] &#61; -1;
            }
        } else {
            continue;
        }

        for (int j &#61; i &#43; 1; j &lt; m; j&#43;&#43;) {
            // 如果两个产品的风险和不超过了总风险&#xff0c;那么两个产品都选
            if (risk[i] &#43; risk[j] &lt;&#61; x) {
                int investI; // 产品I的投资额
                int investJ; // 产品J的投资额

                // 其中优先投资回报率大的
                if (back[i] &gt; back[j]) {
                    // 产品I回报率高&#xff0c;则能投多少投多少&#xff0c;最多不能超过min(总投资, 产品I的最多投资额)
                    investI &#61; MIN(n, invest[i]);
                    // 留给产品J的剩余钱未 n - investI, 而产品J最多投资invest[j]&#xff0c;因此取二者较小值
                    investJ &#61; MIN(n - investI, invest[j]);
                } else {
                    investJ &#61; MIN(n, invest[j]);
                    investI &#61; MIN(n - investJ, invest[i]);
                }

                // 总投资回报
                int invest_back &#61; investI * back[i] &#43; investJ * back[j];

                // 如果当前产品组合的总回报更大&#xff0c;则选当前组合产品
                if (invest_back &gt; max_invest_back) {
                    max_invest_back &#61; invest_back;

                    selectId[0] &#61; -1;
                    selectId[1] &#61; -1;

                    // select的key记录产品的ID&#xff0c;val记录产品的投资额
                    if (investI &gt; 0) {
                        selectId[0] &#61; i;
                        selectFee[0] &#61; investI;
                    }


                    if (investJ &gt; 0) {
                        selectId[1] &#61; j;
                        selectFee[1] &#61; investJ;
                    }
                }
            }
        }
    }

    for (int i &#61; 0; i &lt; m; i&#43;&#43;) {
        if(i &#61;&#61; selectId[0]) {
            printf(&#34;%d&#34;, selectFee[0]);
        } else if(i &#61;&#61; selectId[1]) {
            printf(&#34;%d&#34;, selectFee[1]);
        } else {
            printf(&#34;%d&#34;, 0);
        }

        if(i &lt; m - 1) {
            printf(&#34; &#34;);
        }
    }

    return 0;
}</code></pre> 
<p></p>
                </div>
        </div>
        <div id="treeSkill"></div>
        <div id="blogExtensionBox" style="width:400px;margin:auto;margin-top:12px" class="blog-extension-box"></div>
    <script>
  $(function() {
    setTimeout(function () {
      var mathcodeList = document.querySelectorAll('.htmledit_views img.mathcode');
      if (mathcodeList.length > 0) {
        for (let i = 0; i < mathcodeList.length; i++) {
          if (mathcodeList[i].naturalWidth === 0 || mathcodeList[i].naturalHeight === 0) {
            var alt = mathcodeList[i].alt;
            alt = '\\(' + alt + '\\)';
            var curSpan = $('<span class="img-codecogs"></span>');
            curSpan.text(alt);
            $(mathcodeList[i]).before(curSpan);
            $(mathcodeList[i]).remove();
          }
        }
        MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
      }
    }, 1000)
  });
</script>
</div></html>